import { AttributeType } from "../core/AttributeSystem";
import { EntityCategory } from "../core/BattleEntity";

// 实体基础配置接口
export interface IEntityConfig {
    id: number;                    // 配置ID
    name: string;                  // 实体名称
    category: EntityCategory;      // 实体类别
    prefab: string;                // 预制体路径
    scale: number;                 // 缩放
    
    // 基础属性
    attributes: {
        [key in AttributeType]?: number;
    };
    
    // 特殊属性
    specialAttributes?: {
        [key: number]: number;
    };
    
    // 视觉表现
    visual: {
        animationType: AnimationType;  // 动画类型
        animationPath?: string;        // 动画资源路径
        effectScale?: number;          // 特效缩放
        shadowSize?: number;           // 阴影大小
    };
    
    // 碰撞设置
    collision: {
        radius: number;               // 碰撞半径
        height?: number;              // 碰撞高度(用于胶囊体)
        offset: cc.Vec2;              // 碰撞偏移
        isTrigger: boolean;           // 是否为触发器
    };
    
    // 技能设置
    skills?: number[];               // 技能ID列表
    
    // 初始Buff
    buffs?: number[];                // Buff ID列表
}

// 英雄配置接口
export interface IHeroConfig extends IEntityConfig {
    weaponSlots: number;            // 武器槽数量
    autoHealingRate: number;        // 自动回血率
    autoHealingInterval: number;    // 自动回血间隔
    experienceToLevelUp: number[];  // 升级所需经验
    attributesPerLevel: {           // 每级属性增长
        [key in AttributeType]?: number;
    };
}

// 怪物配置接口
export interface IMonsterConfig extends IEntityConfig {
    level: number;                   // 怪物等级
    monsterType: number;             // 怪物类型
    wanderBehavior?: WanderBehavior; // 游荡行为
    aggressiveness: number;          // 攻击性(0-100)
    alertRadius: number;             // 警戒半径
    followDistance: number;          // 追踪距离
    
    // 掉落设置
    drops: {
        exp: number;                 // 经验值
        coin: number;                // 金币
        items?: {                    // 物品掉落
            id: number;              // 物品ID
            chance: number;          // 掉落几率(0-1)
            count: [number, number]; // 数量范围[最小,最大]
        }[];
    };
    
    // 变异设置(精英/Boss特殊属性)
    eliteModifiers?: {
        hpMultiplier: number;        // 生命倍率
        damageMultiplier: number;    // 伤害倍率
        additionalSkills?: number[]; // 额外技能
        additionalBuffs?: number[];  // 额外Buff
    };
}

// 塔配置接口
export interface ITowerConfig extends IEntityConfig {
    level: number;                   // 塔等级
    upgradePrice: number[];          // 升级价格
    buildCost: number;               // 建造费用
    buildTime: number;               // 建造时间
    attackRange: number;             // 攻击范围
    targetPriority: TargetPriority;  // 目标优先级
    canAttackFlying: boolean;        // 是否可攻击飞行单位
    rotationSpeed: number;           // 旋转速度
    
    // 升级属性增长
    upgradeBonus: {
        [key in AttributeType]?: number;
    }[];
}

// 精灵配置接口
export interface IElfConfig extends IEntityConfig {
    linkTowerTypeA: number;         // 连携塔类型A
    linkTowerTypeB: number;         // 连携塔类型B
    baseAttackAddBL: number;        // 基础攻击加成比例
    inheritAttributes: number[];    // 继承属性列表
    vigilantMaxTime: number;        // 警戒最大时间
}

// 投射物配置
export interface IProjectileConfig extends IEntityConfig {
    speed: number;                  // 速度
    lifeTime: number;               // 存活时间
    hitCount: number;               // 可击中次数
    speedType: number;              // 速度类型
    speedAdd: number;               // 加速度
    bulletPrefab: string;           // 子弹预制体
    bulletOffset: number;           // 子弹角度偏移
    bulletOffsetXY: [number, number]; // 子弹位置偏移
    bulletIsTop: number;            // 是否在顶层
    
    // 追踪设置
    isTracking: boolean;            // 是否追踪
    trackingInterval: number;       // 追踪间隔
}

// 动画类型枚举
export enum AnimationType {
    SPRITE = 0,    // 精灵动画
    SPINE = 1,     // Spine骨骼动画
    FRAME = 2,     // 帧动画
    MODEL = 3      // 3D模型
}

// 游荡行为枚举
export enum WanderBehavior {
    NONE = 0,      // 不游荡
    RANDOM = 1,    // 随机游荡
    PATROL = 2,    // 巡逻路线
    GUARD = 3      // 守卫区域
}

// 目标优先级枚举
export enum TargetPriority {
    NEAREST = 0,   // 最近目标
    LOWEST_HP = 1, // 最低生命值
    HIGHEST_HP = 2, // 最高生命值
    STRONGEST = 3, // 最强目标
    WEAKEST = 4    // 最弱目标
}

// 实体配置管理器
export class EntityConfigManager {
    private static _instance: EntityConfigManager;
    
    private _heroConfigs: Map<number, IHeroConfig> = new Map();
    private _monsterConfigs: Map<number, IMonsterConfig> = new Map();
    private _towerConfigs: Map<number, ITowerConfig> = new Map();
    private _elfConfigs: Map<number, IElfConfig> = new Map();
    private _projectileConfigs: Map<number, IProjectileConfig> = new Map();
    
    private constructor() {
        // 初始化逻辑
    }
    
    public static get instance(): EntityConfigManager {
        if (!this._instance) {
            this._instance = new EntityConfigManager();
        }
        return this._instance;
    }
    
    // 加载配置
    public loadConfigs(configs: any): void {
        // 处理加载的配置数据
        this.loadHeroConfigs(configs.heroes || []);
        this.loadMonsterConfigs(configs.monsters || []);
        this.loadTowerConfigs(configs.towers || []);
        this.loadElfConfigs(configs.elves || []);
        this.loadProjectileConfigs(configs.projectiles || []);
    }
    
    // 加载英雄配置
    private loadHeroConfigs(configs: any[]): void {
        configs.forEach(config => {
            this._heroConfigs.set(config.id, config);
        });
    }
    
    // 加载怪物配置
    private loadMonsterConfigs(configs: any[]): void {
        configs.forEach(config => {
            this._monsterConfigs.set(config.id, config);
        });
    }
    
    // 加载塔配置
    private loadTowerConfigs(configs: any[]): void {
        configs.forEach(config => {
            this._towerConfigs.set(config.id, config);
        });
    }
    
    // 加载精灵配置
    private loadElfConfigs(configs: any[]): void {
        configs.forEach(config => {
            this._elfConfigs.set(config.id, config);
        });
    }
    
    // 加载投射物配置
    private loadProjectileConfigs(configs: any[]): void {
        configs.forEach(config => {
            this._projectileConfigs.set(config.id, config);
        });
    }
    
    // 获取英雄配置
    public getHeroConfig(id: number): IHeroConfig {
        return this._heroConfigs.get(id);
    }
    
    // 获取怪物配置
    public getMonsterConfig(id: number): IMonsterConfig {
        return this._monsterConfigs.get(id);
    }
    
    // 获取塔配置
    public getTowerConfig(id: number): ITowerConfig {
        return this._towerConfigs.get(id);
    }
    
    // 获取精灵配置
    public getElfConfig(id: number): IElfConfig {
        return this._elfConfigs.get(id);
    }
    
    // 获取投射物配置
    public getProjectileConfig(id: number): IProjectileConfig {
        return this._projectileConfigs.get(id);
    }
    
    // 根据类别获取配置
    public getConfigByCategory(category: EntityCategory, id: number): IEntityConfig {
        switch (category) {
            case EntityCategory.HERO:
                return this.getHeroConfig(id);
            case EntityCategory.MONSTER:
                return this.getMonsterConfig(id);
            case EntityCategory.TOWER:
                return this.getTowerConfig(id);
            case EntityCategory.ELF:
                return this.getElfConfig(id);
            case EntityCategory.PROJECTILE:
                return this.getProjectileConfig(id);
            default:
                return null;
        }
    }
} 